Chip 2007 January, February, March & April/Chip-Cover-CD-2007-02.iso/Pakiet bezpieczenstwa/mini Pentoo LiveCD 2006.1/mpentoo-2006.1.iso/livecd.squashfs/usr/lib/python2.4/test/test_long.pyc

Python Compiled Bytecode | 2005-10-18 | 17KB | 575 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.4)

from test.test_support import verify, verbose, TestFailed, fcmp
from string import join
from random import random, randint
SHIFT = 15
BASE = 2 ** SHIFT
MASK = BASE - 1
KARATSUBA_CUTOFF = 70
MAXDIGITS = 15
special = map(long, [
    0,
    1,
    2,
    BASE,
    BASE >> 1])
special.append(0x5555555555555555L)
special.append(0xAAAAAAAAAAAAAAAAL)
p2 = 0x4L
for i in range(2 * SHIFT):
    special.append(p2 - 1)
    p2 = p2 << 1

del p2
special = special + map((lambda x: ~x), special) + map((lambda x: -x), special)

def check(ok, *args):
    if not ok:
        raise TestFailed, join(map(str, args), ' ')



def getran(ndigits):
    verify(ndigits > 0)
    nbits_hi = ndigits * SHIFT
    nbits_lo = (nbits_hi - SHIFT) + 1
    answer = 0x0L
    nbits = 0
    r = int(random() * SHIFT * 2) | 1
    while nbits < nbits_lo:
        bits = (r >> 1) + 1
        bits = min(bits, nbits_hi - nbits)
        None(verify if bits <= bits else bits <= SHIFT)
        nbits = nbits + bits
        answer = answer << bits
        if r & 1:
            answer = answer | (1 << bits) - 1

        r = int(random() * SHIFT * 2)
    None(verify if nbits <= nbits else nbits <= nbits_hi)
    if random() < 0.5:
        answer = -answer

    return answer


def getran2(ndigits):
    answer = 0x0L
    for i in range(ndigits):
        answer = answer << SHIFT | randint(0, MASK)

    if random() < 0.5:
        answer = -answer

    return answer


def test_division_2(x, y):
    (q, r) = divmod(x, y)
    q2 = x // y
    r2 = x % y
    pab = x * y
    pba = y * x
    check(pab == pba, 'multiplication does not commute for', x, y)
    check(q == q2, 'divmod returns different quotient than / for', x, y)
    check(r == r2, 'divmod returns different mod than % for', x, y)
    check(x == q * y + r, 'x != q*y + r after divmod on', x, y)
    if y > 0:
        None(check if r <= r else r < y, 'bad mod from divmod on', x, y)
    elif r < r:
        pass

    check(r <= 0, 'bad mod from divmod on', x, y)


def test_division(maxdigits = MAXDIGITS):
    if verbose:
        print 'long / * % divmod'

    digits = range(1, maxdigits + 1) + range(KARATSUBA_CUTOFF, KARATSUBA_CUTOFF + 14)
    digits.append(KARATSUBA_CUTOFF * 3)
    for lenx in digits:
        x = getran(lenx)
        for leny in digits:
            if not getran(leny):
                pass
            y = 0x1L
            test_division_2(x, y)




def test_karatsuba():
    if verbose:
        print 'Karatsuba'

    digits = range(1, 5) + range(KARATSUBA_CUTOFF, KARATSUBA_CUTOFF + 10)
    digits.extend([
        KARATSUBA_CUTOFF * 10,
        KARATSUBA_CUTOFF * 100])
    bits = [ digit * SHIFT for digit in digits ]
    for abits in bits:
        a = (0x1L << abits) - 1
        for bbits in bits:
            b = (0x1L << bbits) - 1
            x = a * b
            y = ((0x1L << abits + bbits) - (0x1L << abits) - (0x1L << bbits)) + 1
            check(x == y, 'bad result for', a, '*', b, x, y)




def test_bitop_identities_1(x):
    check(x & 0 == 0, 'x & 0 != 0 for', x)
    check(x | 0 == x, 'x | 0 != x for', x)
    check(x ^ 0 == x, 'x ^ 0 != x for', x)
    check(x & -1 == x, 'x & -1 != x for', x)
    check(x | -1 == -1, 'x | -1 != -1 for', x)
    check(x ^ -1 == ~x, 'x ^ -1 != ~x for', x)
    check(x == ~~x, 'x != ~~x for', x)
    check(x & x == x, 'x & x != x for', x)
    check(x | x == x, 'x | x != x for', x)
    check(x ^ x == 0, 'x ^ x != 0 for', x)
    check(x & ~x == 0, 'x & ~x != 0 for', x)
    check(x | ~x == -1, 'x | ~x != -1 for', x)
    check(x ^ ~x == -1, 'x ^ ~x != -1 for', x)
    None(check if 1 + ~x == 1 + ~x else 1 + ~x == ~(x - 1), 'not -x == 1 + ~x == ~(x-1) for', x)
    for n in range(2 * SHIFT):
        p2 = 0x2L ** n
        check(x << n >> n == x, 'x << n >> n != x for', x, n)
        check(x // p2 == x >> n, 'x // p2 != x >> n for x n p2', x, n, p2)
        check(x * p2 == x << n, 'x * p2 != x << n for x n p2', x, n, p2)
        None(check if (x >> n) << n == (x >> n) << n else (x >> n) << n == x & ~(p2 - 1), 'not x & -p2 == x >> n << n == x & ~(p2 - 1) for x n p2', x, n, p2)



def test_bitop_identities_2(x, y):
    check(x & y == y & x, 'x & y != y & x for', x, y)
    check(x | y == y | x, 'x | y != y | x for', x, y)
    check(x ^ y == y ^ x, 'x ^ y != y ^ x for', x, y)
    check(x ^ y ^ x == y, 'x ^ y ^ x != y for', x, y)
    check(x & y == ~(~x | ~y), 'x & y != ~(~x | ~y) for', x, y)
    check(x | y == ~(~x & ~y), 'x | y != ~(~x & ~y) for', x, y)
    check(x ^ y == (x | y) & ~(x & y), 'x ^ y != (x | y) & ~(x & y) for', x, y)
    check(x ^ y == x & ~y | ~x & y, 'x ^ y == (x & ~y) | (~x & y) for', x, y)
    check(x ^ y == (x | y) & (~x | ~y), 'x ^ y == (x | y) & (~x | ~y) for', x, y)


def test_bitop_identities_3(x, y, z):
    check(x & y & z == x & y & z, '(x & y) & z != x & (y & z) for', x, y, z)
    check(x | y | z == x | y | z, '(x | y) | z != x | (y | z) for', x, y, z)
    check(x ^ y ^ z == x ^ y ^ z, '(x ^ y) ^ z != x ^ (y ^ z) for', x, y, z)
    check(x & (y | z) == x & y | x & z, 'x & (y | z) != (x & y) | (x & z) for', x, y, z)
    check(x | y & z == (x | y) & (x | z), 'x | (y & z) != (x | y) & (x | z) for', x, y, z)


def test_bitop_identities(maxdigits = MAXDIGITS):
    if verbose:
        print 'long bit-operation identities'

    for x in special:
        test_bitop_identities_1(x)

    digits = range(1, maxdigits + 1)
    for lenx in digits:
        x = getran(lenx)
        test_bitop_identities_1(x)
        for leny in digits:
            y = getran(leny)
            test_bitop_identities_2(x, y)
            test_bitop_identities_3(x, y, getran((lenx + leny) // 2))




def slow_format(x, base):
    if (x, base) == (0, 8):
        return '0L'

    digits = []
    sign = 0
    if x < 0:
        sign = 1
        x = -x

    while x:
        (x, r) = divmod(x, base)
        digits.append(int(r))
    digits.reverse()
    if not digits:
        pass
    digits = [
        0]
    return '-'[:sign] + {
        8: '0',
        10: '',
        16: '0x' }[base] + join(map((lambda i: '0123456789ABCDEF'[i]), digits), '') + 'L'


def test_format_1(x):
    atol = atol
    import string
    for base, mapper in ((8, oct), (10, repr), (16, hex)):
        got = mapper(x)
        expected = slow_format(x, base)
        check(got == expected, mapper.__name__, 'returned', got, 'but expected', expected, 'for', x)
        check(atol(got, 0) == x, 'atol("%s", 0) !=' % got, x)

    got = str(x)
    expected = slow_format(x, 10)[:-1]
    check(got == expected, mapper.__name__, 'returned', got, 'but expected', expected, 'for', x)


def test_format(maxdigits = MAXDIGITS):
    if verbose:
        print 'long str/hex/oct/atol'

    for x in special:
        test_format_1(x)

    for i in range(10):
        for lenx in range(1, maxdigits + 1):
            x = getran(lenx)
            test_format_1(x)




def test_misc(maxdigits = MAXDIGITS):
    if verbose:
        print 'long miscellaneous operations'

    import sys as sys
    hugepos = sys.maxint
    hugeneg = -hugepos - 1
    hugepos_aslong = long(hugepos)
    hugeneg_aslong = long(hugeneg)
    check(hugepos == hugepos_aslong, 'long(sys.maxint) != sys.maxint')
    check(hugeneg == hugeneg_aslong, 'long(-sys.maxint-1) != -sys.maxint-1')

    try:
        check(int(hugepos_aslong) == hugepos, 'converting sys.maxint to long and back to int fails')
    except OverflowError:
        raise TestFailed, 'int(long(sys.maxint)) overflowed!'


    try:
        check(int(hugeneg_aslong) == hugeneg, 'converting -sys.maxint-1 to long and back to int fails')
    except OverflowError:
        raise TestFailed, 'int(long(-sys.maxint-1)) overflowed!'

    x = hugepos_aslong + 1

    try:
        y = int(x)
    except OverflowError:
        raise TestFailed, "int(long(sys.maxint) + 1) mustn't overflow"

    if not isinstance(y, long):
        raise TestFailed('int(long(sys.maxint) + 1) should have returned long')

    x = hugeneg_aslong - 1

    try:
        y = int(x)
    except OverflowError:
        raise TestFailed, "int(long(-sys.maxint-1) - 1) mustn't overflow"

    if not isinstance(y, long):
        raise TestFailed('int(long(-sys.maxint-1) - 1) should have returned long')


    class long2(long):
        pass

    x = long2(0x1L << 100)
    y = int(x)
    if type(y) is not long:
        raise TestFailed('overflowing int conversion must return long not long subtype')



def test_auto_overflow():
    import math as math
    import sys
    if verbose:
        print 'auto-convert int->long on overflow'

    special = [
        0,
        1,
        2,
        3,
        sys.maxint - 1,
        sys.maxint,
        sys.maxint + 1]
    sqrt = int(math.sqrt(sys.maxint))
    special.extend([
        sqrt - 1,
        sqrt,
        sqrt + 1])
    []([ -i for i in special ])

    def checkit(*args):
        verify(got == expected, 'for %r expected %r got %r' % (args, expected, got))

    for x in special:
        longx = long(x)
        expected = -longx
        got = -x
        checkit('-', x)
        for y in special:
            longy = long(y)
            expected = longx + longy
            got = x + y
            checkit(x, '+', y)
            expected = longx - longy
            got = x - y
            checkit(x, '-', y)
            expected = longx * longy
            got = x * y
            checkit(x, '*', y)
            if abs(y) < 5:
                pass
            None if x == 0 else None if y else special.extend




def test_float_overflow():
    import math
    if verbose:
        print 'long->float overflow'

    for x in (-2.0, -1.0, 0.0, 1.0, 2.0):
        verify(float(long(x)) == x)

    shuge = '12345' * 120
    huge = 0x1L << 30000
    mhuge = -huge
    namespace = {
        'huge': huge,
        'mhuge': mhuge,
        'shuge': shuge,
        'math': math }
    for test in [
        'float(huge)',
        'float(mhuge)',
        'complex(huge)',
        'complex(mhuge)',
        'complex(huge, 1)',
        'complex(mhuge, 1)',
        'complex(1, huge)',
        'complex(1, mhuge)',
        '1. + huge',
        'huge + 1.',
        '1. + mhuge',
        'mhuge + 1.',
        '1. - huge',
        'huge - 1.',
        '1. - mhuge',
        'mhuge - 1.',
        '1. * huge',
        'huge * 1.',
        '1. * mhuge',
        'mhuge * 1.',
        '1. // huge',
        'huge // 1.',
        '1. // mhuge',
        'mhuge // 1.',
        '1. / huge',
        'huge / 1.',
        '1. / mhuge',
        'mhuge / 1.',
        '1. ** huge',
        'huge ** 1.',
        '1. ** mhuge',
        'mhuge ** 1.',
        'math.sin(huge)',
        'math.sin(mhuge)',
        'math.sqrt(huge)',
        'math.sqrt(mhuge)',
        'math.floor(huge)',
        'math.floor(mhuge)']:

        try:
            eval(test, namespace)
        except OverflowError:
            pass

        raise TestFailed('expected OverflowError from %s' % test)
        if float(shuge) == int(shuge):
            raise TestFailed('float(shuge) should not equal int(shuge)')
            continue



def test_logs():
    import math
    if verbose:
        print 'log and log10'

    LOG10E = math.log10(math.e)
    for exp in range(10) + [
        100,
        1000,
        10000]:
        value = 10 ** exp
        log10 = math.log10(value)
        verify(fcmp(log10, exp) == 0)
        expected = exp / LOG10E
        log = math.log(value)
        verify(fcmp(log, expected) == 0)

    for bad in (-(0x1L << 10000), -0x2L, 0x0L):

        try:
            math.log(bad)
            raise TestFailed('expected ValueError from log(<= 0)')
        except ValueError:
            pass


        try:
            math.log10(bad)
            raise TestFailed('expected ValueError from log10(<= 0)')
        continue
        except ValueError:
            continue





def test_mixed_compares():
    import math
    import sys
    if verbose:
        print 'mixed comparisons'


    class Rat:

        def __init__(self, value):
            if isinstance(value, (int, long)):
                self.n = value
                self.d = 1
            elif isinstance(value, float):
                (f, e) = math.frexp(abs(value))
                if not f == 0:
                    if f <= f:
                        pass
                    elif not f < 1.0:
                        raise AssertionError
                CHUNK = 28
                top = 0
                while f:
                    f = math.ldexp(f, CHUNK)
                    digit = int(f)
                    if not digit >> CHUNK == 0:
                        raise AssertionError
                    top = top << CHUNK | digit
                    f -= digit
                    if f <= f:
                        pass
                    elif not f < 1.0:
                        raise AssertionError
                    e -= CHUNK
                if e >= 0:
                    n = top << e
                    d = 1
                else:
                    n = top
                    d = 1 << -e
                if value < 0:
                    n = -n

                self.n = n
                self.d = d
                if not float(n) / float(d) == value:
                    raise AssertionError
            else:
                raise TypeError("can't deal with %r" % val)


        def __cmp__(self, other):
            if not isinstance(other, Rat):
                other = Rat(other)

            return cmp(self.n * other.d, self.d * other.n)


    cases = [
        0,
        0.001,
        0.98999999999999999,
        1.0,
        1.5,
        1e+20,
        9.9999999999999997e+199]
    for t in (2.0 ** 48, 2.0 ** 50, 2.0 ** 53):
        cases.extend([
            t - 1.0,
            t - 0.29999999999999999,
            t,
            t + 0.29999999999999999,
            t + 1.0,
            long(t - 1),
            long(t),
            long(t + 1)])

    cases.extend([
        0,
        1,
        2,
        sys.maxint,
        float(sys.maxint)])
    t = long(9.9999999999999997e+199)
    cases.extend([
        0x0L,
        0x1L,
        0x2L,
        0x1L << 20000,
        t - 1,
        t,
        t + 1])
    []([ -x for x in cases ])
    for x in cases:
        Rx = Rat(x)
        for y in cases:
            Ry = Rat(y)
            Rcmp = cmp(Rx, Ry)
            xycmp = cmp(x, y)
            if x == y != Rcmp == 0:
                raise TestFailed('%r == %r %d' % (x, y, Rcmp))

            if x != y != Rcmp != 0:
                raise TestFailed('%r != %r %d' % (x, y, Rcmp))

            if x < y != Rcmp < 0:
                raise TestFailed('%r < %r %d' % (x, y, Rcmp))

            if x <= y != Rcmp <= 0:
                raise TestFailed('%r <= %r %d' % (x, y, Rcmp))

            if (x > y) != (Rcmp > 0):
                raise TestFailed('%r > %r %d' % (x, y, Rcmp))

            if (x >= y) != (Rcmp >= 0):
                raise TestFailed('%r >= %r %d' % (x, y, Rcmp))
                continue



test_division()
test_karatsuba()
test_bitop_identities()
test_format()
test_misc()
test_auto_overflow()
test_float_overflow()
test_logs()
test_mixed_compares()